Data Scope Origination Within Aggregation Operations

ABSTRACT

A computer-implemented method for generating a report from a report definition specifying a plurality of data scopes for a dataset includes interpreting, with a processor, a report definition for the report, the report definition comprising a calculation expression for populating a unit of the report, the calculation expression comprising a data aggregation operation, the data aggregation operation comprising an originating reference to a further data scope, accessing a memory coupled to the processor to obtain data from the dataset for respective subsets of the dataset corresponding with the further data scope, determining, with the processor, an output value for the calculation expression in accordance with the obtained data and the data aggregation operation, and rendering the report based on the output value.

BACKGROUND OF THE DISCLOSURE Brief Description of Related Technology

Businesses and other entities use software to generate reports on whichdecisions are based. To be useful, the reports typically group andaggregate data. For instance, when reporting on sales for a company, amere list of every transaction does little good when making businessdecisions. By grouping and aggregating the data into meaningfulcategories (e.g., total sales broken down by product and region), datais transformed into more useful information.

The data is often grouped via a definition of the report. The reportdefinition sets forth instructions for the layout of the report, thesource(s) of the data, and the aggregation operations and othercomputational processing of the data. The aggregation operations (e.g.,a sum operation) may group the data in accordance with a level ofdetail, or data scope, of the data being aggregated. For example, salesmay be aggregated by year, by quarter, by month, by region, by customer,etc., as well as various combinations thereof. Such data scopes may beestablished implicitly (e.g., by the context or location of theaggregation operation) or explicitly (e.g., by express declarationwithin the aggregation operation).

SUMMARY OF THE DISCLOSURE

Methods, systems, and computer program products are directed tosupporting data scopes originated within data aggregation operations.The data scopes may then be used in the data aggregation operations. Thedata scopes need not be explicitly created outside of a data aggregationoperation for data display in a report.

In accordance with one aspect of the disclosure, a report definitionincludes a calculation expression for populating a unit of a report. Thecalculation expression includes a data aggregation operation that, inturn, includes an originating reference to a data scope. With theoriginating reference, the data scope need not be one of the data scopesdefined or introduced elsewhere in the report definition.

This Summary is provided to introduce a selection of concepts in asimplified form that are further described below in the DetailedDescription. This Summary is not intended to identify key features oressential features of the claimed subject matter, nor is it intended tobe used to limit the scope of the claimed subject matter.

DESCRIPTION OF THE DRAWING FIGURES

For a more complete understanding of the disclosure, reference should bemade to the following detailed description and accompanying drawingfigures, in which like reference numerals identify like elements in thefigures.

FIG. 1 is one example of a report or other data display having a numberof computations that may be implemented via data scopes originatedwithin aggregation operations in accordance with one embodiment.

FIG. 2 is a schematic representation of a report definition of thereport of FIG. 1.

FIG. 3 is a schematic representation of one example of a calculationmethodology for implementing the computations for the report of FIG. 1.

FIG. 4 is a schematic representation of another example of a calculationmethodology for implementing the computations for the report of FIG. 1.

FIG. 5 is another example of a report or other data display having anumber of computations that may be implemented via data scopesoriginated within aggregation operations in accordance with oneembodiment.

FIG. 6 is a schematic representation of a report definition of thereport of FIG. 5.

FIG. 7 is a schematic representation of one example of a calculationmethodology for implementing the computations for the report of FIG. 5.

FIG. 8 is a block diagram of an exemplary business intelligence systemconfigured to develop and render reports and other data displays inwhich data scopes are originated within aggregation operations inaccordance with one embodiment.

FIG. 9 is a flow diagram of an exemplary computer-implemented method togenerate a report from a report definition in which data scopes areoriginated within aggregation operations in accordance with oneembodiment.

FIG. 10 is a block diagram of a computing environment in accordance withone embodiment for implementation of one or more of the disclosedmethods and systems.

While the disclosed systems and methods are susceptible of embodimentsin various forms, there are illustrated in the drawing (and willhereafter be described) specific embodiments of the invention, with theunderstanding that the disclosure is intended to be illustrative, and isnot intended to limit the invention to the specific embodimentsdescribed and illustrated herein.

DETAILED DESCRIPTION

The disclosed methods and systems are directed to identifying orestablishing data scopes within instructions that set forth aggregationoperations. The data scopes may be introduced via constructs of a reportdefinition language in which the instructions are written or developed.The instructions for an aggregation operation may thus introduce orotherwise originate a data scope over which the aggregation operation isimplemented. The aggregation operation may include a reference to thedata scope being introduced or originated. Origination of the data scopewithin the aggregation operation may avoid a separate, express creationof the data scope for the report via other instructions in a reportdefinition. Instantiation, persistence, and other handling of thecorresponding groups of data outside of the aggregation operation maythus be avoided. The origination of the data scope may occur inconnection with a variety of aggregation operations, including anyaggregation calculation or other operation in which a data scope may bespecified. In some embodiments, the aggregation operation may originatethe data scope by taking a scope function as an argument.

The disclosed methods and systems may allow aggregation operations toreference data scopes not explicitly defined in a report definition forcorresponding data presentation in a report. For example, theaggregation operation may include a reference to a data scope that maybe inferred from a combination or intersection of other data scopesexplicitly defined in the report definition. In other examples, theaggregation operation may include a reference to a data scope thatcannot be inferred from the other data scopes in the report definition.

The disclosed methods and systems may be used to facilitate calculationsthat cross a boundary of a desired data scope for a calculationinstruction. For example, a calculation may involve the total sales fora product as a percentage of the total sales for the entire productcategory. For most such calculations, the calculation instructions mayreference a result for an existing data scope, which has been createdfor displaying such data. In some cases, however, the data scope doesnot exist to support such calculations. The disclosed methods andsystems avoid forcing a report developer to explicitly create the datascope in the report definition. Such express aggregation of the data forthe desired data scope may allow the data scope to be referenced later,but involves hiding or discarding the aggregated data corresponding withthe data scope because the data is not actually desired in the report.Express aggregation may thus be undesirably inefficient, and may involveinstantiation, transmission, and other handling and processing of largeamounts of visual data only to discard the data as unneeded.

The disclosed methods and systems may also address cases where expresslydeclaring the data scope for an aggregation operation is not possible orpracticable. Some cases involve the aggregation of data for anintersection or combination of data scopes introduced in the reportdefinition. For example, the desired data scope may be inferable from anumber of ancestor or outer data scopes to define groups or subsets ofthe data along one or more axes of multidimensional data. Other casesarise when the desired group scope cannot be inferred from combinationsof data scopes involved in other calculations in the report definition.For example, the desired data scope may be synthesized or originated forthe same calculation expression (or data aggregation operation thereof)in which the desired data scope is used. Still other cases may involveintersections or other combinations of data scopes in which one or moreof the data scopes is synthesized or originated within the calculationexpression or aggregation operation. The origination of a data scopewithin a calculation expression or aggregation operation may thusinvolve a multidimensional scope intersection, the synthesis ororigination of a single dimensional data scope, or a multidimensionalscope intersection involving the synthesis or origination of one or moredata scopes.

In some embodiments, the reference to a multidimensional data scope maybe embedded or otherwise incorporated in a calculation expression ordata aggregation operation or function thereof in which a data scope maybe identified. The expression, operation, or function may take thereference to the multidimensional data scope as an argument orparameter. In some embodiments, the reference is configured as a scopefunction taken as an argument. The scope function may, in turn, take anumber of arguments to define the multidimensional data scope. Thecalculation or aggregation may thus be implemented in the context of, orestablished by, the resulting multidimensional data scope.

The disclosed methods and systems may provide a number of benefits inthe context of business intelligence reports. For instance, thereferences to data scopes not introduced elsewhere in a reportdefinition may improve the efficiency of a business intelligence system,including, for example, the report generation software implementedtherein. The efficiency and other improvements may involve decreases indata transmissions and/or data storage. Alternatively or additionally,the instantiation of large groups of data for display in a report may beminimized or eliminated. In these and other ways, the disclosed methodsand systems may improve the performance of business intelligencesystems, report generation systems, and/or the processing systemsthereof.

Although described in the context of tabular report arrangements, thedisclosed methods and systems may be used with a wide variety of reporttypes, formats, and arrangements. For example, the disclosed methods andsystems are well-suited for use with reports in which the data isdisplayed in charts or other non-tabular arrangements. The reportsgenerated by the disclosed methods and systems may include or involve awide variety of data displays and are not limited to any particularoutput device or user interface. The disclosed methods and systems arealso not limited to any particular type of report definition, reportdefinition language, or report generation software.

The disclosed methods and systems are not limited to a particular typeof business intelligence system, and may be used with different types ofreport development software systems. For example, the disclosed methodsand systems are well suited for, but not limited to, use with SQLServer® Reporting Services (SSRS) software commercially available fromMicrosoft Corporation.

FIG. 1 depicts an exemplary report 100 for which the disclosed systemsand methods may be useful. The report 100 has a tabular data displayarrangement. Data is arranged in a number of columns 102 and a number ofrows 104. Data is aggregated for presentation within cells 106 inaccordance with the respective column 102 and the respective row 104.The cells 106 may be organized under multiple levels of detail or datascopes along the columns 102 and/or the rows 104. In this example, thecolumns 102 include outer columns 108 to group the data by year (e.g.,2010, 2011) and inner columns 110 to group the data by sales channel(e.g., bricks and mortar or B&M, Internet) within each year. The rows104 include outer rows 112 to group the data by country (e.g., US,Canada) and inner rows to group the data by region (e.g., West, East)within each country.

The data scope establishes or defines subsets or groups of a dataset.For example, the data scope may collect in a respective group all of thesales in the dataset for a particular region or country. As shown inthis example, data scopes may establish a hierarchy of such groups.Groups for an outer scope may include any number of groups for innerscopes. Each group for an inner scope is contained within a group for anouter scope. For example, the groups defined via the region scope arecontained within respective groups for the country scope. A reportdefinition may thus use outer and inner scopes to define a specificgroup of data from the dataset (e.g., all data in the dataset associatedwith a specific month, April, of a given year, 2010). The outer scopemay be considered an ancestor or parent scope of the inner scope(s),which may thus be considered a descendant or child scope.

The data scope may determine the subset or group of data to which afunction or operation is applied. In the example of FIG. 1, the datascopes are used to define the parameters of several sales computations.For instance, the sales for a given channel, year, region, and countryare aggregated, before being aggregated further for each country. In anadjacent column, a computation presents these aggregations as apercentage of total sales, such that a sum for total sales is determinedbased on the data scope. In this example, the total sales for thepercentage calculation are computed either for a given region or a givencountry, depending on the location of the cell. A variety of aggregationoperations, functions, computations, or other elements in a report mayuse a data scope to identify the subset or group of data to which theoperation or other element is applied.

Other exemplary uses of scopes are provided in U.S. Patent PublicationNo. 2011/0179051 (“Dynamic Expansion of Data Calculation Scopes”), theentire disclosure of which is incorporated by reference.

FIG. 2 depicts a schematic representation of a report definition 120 forthe report 100 of FIG. 1. The report definition 120 includes a number ofcolumn headers 122 and a number of row headers 124 configured toestablish the columns and rows of the report, respectively. The columnheaders 122 and the row headers 124 may be either static or dynamic.Dynamic headers allow the table to expand through a variable number ofcolumns or rows for a given data scope to accommodate the data providedby the dataset. Static headers do not support expansion, but may bereplicated for each column (or set of columns) created in connectionwith an outer (or parent) dynamic header. In this example, the columnheaders 122 for the “Sales” and “% Tot” columns are static, while thecolumn headers 122 for the “Year” and “Channel” data scopes are dynamic.The row header 124 for the “Total” row is static, while the row headers124 for the “Country” and “Region” data scopes are dynamic. The dynamiccolumn and row headers may be distinguished by a declarative marking(e.g., brackets) and a field (e.g., database field) of the datasetassociated with the data scope (e.g., “Country”). Further informationregarding the declaration of dynamic rows and columns is set forth inU.S. Pat. No. 7,707,490 (“Systems and Methods for Flexible ReportDesigns Including Table, Matrix, and Hybrid Designs”), the entiredisclosure of which is incorporated by reference.

The report definition 120 includes computer-readable instructionsconfigured to implement the computations for each cell of the report.The computer-readable instructions may be set forth in a variety ofdifferent languages. For example, the instructions may be set forth inaccordance with the Report Definition Language (RDL) standard proposedby Microsoft Corporation, which may then be used with Microsoft® SQLReporting Services (SSRS) report generation software. The RDL standardis configured as an extensible markup language (XML) scheme. Other XMLschema may alternatively or additionally be used. For example, adifferent XML scheme may be used in conjunction with report generationsoftware applications other than SSRS. The report definition 120 neednot use an XML scheme, and instead may be set forth in any reportdefinition or other language.

The instructions include one or more calculation expressions orinstruction(s) for populating one or more cells with a value or otherdata. The calculation expressions or instructions for some of the cellsof the report include a data aggregation function or operation, such asa Sum( ) operation that returns a total value for a group of data. Otherexamples of aggregation operations include a Max( ) operation thatreturns a maximum value of the data group, a Min( ) operation thatreturns a minimum value of the data group, and an Avg( ) operation thatreturns an average value of the data group. Any number of aggregationoperations may be available and supported for use in the reportdefinition 120. Additional and alternative operations may be provided.

The group of data to which an aggregation operation is applied isspecified via the data scope (e.g., group scope) for the aggregationoperation. The aggregation operations are set forth in the reportdefinition 120 in a manner that specifies the data scope. The data scopemay be specified via an argument of the aggregation operation. The datascope may be specified explicitly or implicitly. For example, the datascope may be implicitly specified via the context or location of theaggregation operation, or calculation expression, in the reportdefinition 120. The data scope may thus be context- orlocation-dependent. The location in the report definition, in turn,reflects the location of the cell or other item in the report beingpopulated by the calculation expression. In this example, thecalculation expressions abbreviated as <Calc1> and <Calc2> may beidentical (e.g., Sum([Sales]). The calculation expressions returndifferent result values because the data scopes are context-dependent.The expression computes for <Calc1> the total sales for each distinctcombination of Country, Region, Year, and Channel values. The data scopein each case is an intersection of that distinct combination. Incontrast, the expression computes for <Calc2> the total sales for eachdistinct combination of Country, Year, and Channel values, therebyproviding one or more subtotals that aggregate across Regions. Thedifferences in the data scopes are determined by configuring the reportdefinition 120 such that the <Calc1> expression is contained with theRegion scope on rows (which, in turn, is contained with the Countryscope) and the Channel scope on columns (which, in turn, is containedwith the Year scope). The <Calc2> expression is only contained withinthe Country scope on rows and the Channel scope (and, thus, Year scope)on columns. Further information regarding such implicit scoping isprovided in the above-referenced U.S. Pat. No. 7,707,490 (“Systems andMethods for Flexible Report Designs Including Table, Matrix, and HybridDesigns”). The manner in which a calculation expression or aggregationoperation implicitly establishes a data scope may vary. For example, thedata scope may be inferred from other information in the reportdefinition 120.

The data scope for a calculation expression may also be explicitlyspecified by incorporating a parameter or other identifier in theaggregation operation. In some embodiments, the aggregation operationmay allow a data scope to be identified as an argument. For example, acalculation expression may include Sum([Sales], “Year”), which computethe total sales for the Year regardless of the context or location ofthe calculation expression. The manner in which a calculation expressionor aggregation operation explicitly or expressly establishes a datascope may also vary.

The above-described implicit and explicit scoping may not be sufficientfor all cells or units of a report. Two examples are provided inconnection with the example of FIGS. 1 and 2. Neither implicit norexplicit scoping provides the desired results for the calculationexpressions abbreviated as <Calc3> and <Calc4>. As shown in FIG. 1, theexpression for <Calc3> is intended to compute the percentagecontribution of each channel's yearly sales (within the Country andRegion) relative to the overall total sales in that year within a givenCountry and a given Region. However, the overall total sales figures ineach year for a Country and Region combination are not provided in thereport. Those totals are not computed during execution of the reportdefinition 120. The corresponding groups or subsets of the dataset thatlead to such totals are thus not instantiated.

The report definition 120 may be modified to support such calculations.For example, another column may be added to the report to calculatethose overall total sales figures. The column may have a row headerlabeled “Total” and be contained within the Year scope. The calculationexpression may then use implicit scoping (e.g., Sum([Sales]) to computethe total sales for each distinct combination of Country, Region, andYear values to be used in denominator of the percentage calculation.However, in some cases, adding a column or other modifications to thereport may not be desirable.

Rather than force the report developer to include a separate column tosupport the <Calc3> percentage computation, the aggregation operationmay be configured such that a reference to a further data scope may beincorporated therein. The further data scope need not be specifiedelsewhere in the report definition 120. In this example, the furtherdata scope corresponds with an intersection set (or combination) of twoother data scopes identified in the report definition 120. The furtherdata scope may be specified explicitly by expressly identifying theother data scopes in the reference. The reference may be set forthin-line or be otherwise embedded in the aggregation operation. Forexample, if the aggregation operation is configured as a function, thenthe reference may be expressly provided via one or more arguments. Inone embodiment, the aggregation operation may take as an argument afunction that returns the desired data scope. For example, theaggregation operation for the <Calc3> expression may be set forth asfollows: Sum([Sales])/Sum([Sales], Scope(“Region”,“Year”)). Thedenominator, or divisor, in this example, computes the total sales forthe explicit intersection of the Region scope and the Year scope.Because the Region scope is contained within the Country scope, theexpression establishes that the subtotal calculated is the yearly salesfor each country and region.

In this example, the reference to the otherwise un-introduced data scopeis provided via a Scope( ) function nested or embedded in the expressionof the Sum( ) function. The reference need not be configured as afunction. For example, the reference may be set forth in an alternativeformat in connection with other report definition languages.

The incorporation of the Scope( ) function or other reference originatesand establishes the data scope for the aggregation operation into whichthe function or reference is incorporated. The data scope need not beoriginated or introduced elsewhere in the report definition 120.

The use of the Scope( ) function explicitly specifies the data scope forthe aggregation operation. The above-described implicit scoping may thusbe overridden. Further, the data scope is not limited to explicitlyidentifying a single scope, such as “Year”, which would undesirablycompute the sales for each entire year (rather than for a specificcountry and region, as desired). Instead, the Scope( ) function or otherreference may establish a multidimensional data scope derived from thecombination of two or more data scopes (e.g., “Region” and “Year” in theexample of <Calc3>). Origination of the multidimensional scope computesthe desired value without resorting to, for instance, the artificialcreation of calculations in another column. The report developer thusavoids having to include instructions to hide or discard the column orthe underlying aggregated data. Generation of the report may be moreefficient, as the steps taken to process and handle such aggregated datafor display in the report also become unnecessary.

In the example described above, the Scope( ) function is configured totake two arguments. One argument is the name of a data scope identifiedelsewhere in the report definition 120 for a row (e.g., a row scope),and the other argument is the name of a scope identified elsewhere inthe report definition for a column (e.g., a column scope). The Scope( )function may then be configured to define the data scope correspondingwith the intersection set of the row and column scopes identified asarguments. In other embodiments, the Scope( ) function may be configuredto take additional scopes. The intersection may thus be defined alongmore than two dimensions. Such intersections may be useful with, forinstance, other types of reports, such as non-tabular reports. Forexample, more than two dimensions may be useful in a report arrangementconfigured with a three-dimensional chart or other graphicalrepresentation of data.

With continued reference to FIGS. 1 and 2, the calculation expressionfor <Calc4> provides another example of a reference to amultidimensional scope. The calculation expression for <Calc4> isintended to compute another percentage computation. In this example, thecomputation is for the percentage contribution of a specific channel foran entire country in a given year. The denominator, or divisor, of thecomputation again involves an intersection of a row scope and a columnscope not defined or originated elsewhere in the report definition 120.In this example, the row scope is the Country scope (rather than theRegion scope as in <Calc3>), and the column scope is again the Yearscope. Instead of creating a column to expressly compute a total for theintersection, the calculation expression for <Calc4> may be set forth asfollows: Sum([Sales])/Sum([Sales], Scope(“Country”,“Year”)).

The implementation of the calculation expressions <Calc3> and <Calc4>may use calculation trees, nested calculations, and other calculationschemes. The calculation scheme may avoid having to fully actualize oneor more intermediate calculations. In contrast, adding a column to thereport as described above would involve full actualization of thecalculations directed to determining the denominators or divisors. Suchfull actualization may include instantiation, storage, transmission, andrendering of the underlying data group, the results of the calculation,and/or transmission of the data group and/or results.

FIG. 3 depicts an exemplary calculation methodology or scheme for themultidimensional data scope computations described above. Thecalculation methodologies may be used by a report generation or businessintelligence system to configure database queries and other proceduresdirected to computing the values involved in the above-describedcalculation expressions. In this example, the calculation methodology isconfigured as a pair of calculation trees. A calculation tree 130 isdirected to computing the calculation expression <Calc3>, and acalculation tree 132 is directed to computing the calculation expression<Calc4>. Each calculation tree 130, 132 defines a number of data pathsemanating from a respective entry point 134, 136. In this example, eachcalculation tree 130, 132 includes two data paths to accommodate thecolumn and row scopes of the report definition.

The data path for each calculation expression <Calc3>, <Calc4> includesa number of aggregations to support later summations. Each aggregationmay include establishing data groups associated with a data scope (e.g.,the sales data for each country, for each region thereof, etc.). Theabove-described multidimensional intersections of the scopes aredetermined via combinations of two or more data groups. For example, inthe <Calc3> calculation, a determination 138, labeled <Calc3.2>,provides the denominator or divisor of each calculation expression<Calc3> via a combination of Region and Year groups. A determination140, labeled Calc3.1, for the dividend of each calculation expression<Calc3> is determined by a combination of Region and Channel groups. Theresults of the denominator (divisor) and numerator (dividend)determinations 138, 140 are then used (e.g., <Calc3.1>/<Calc3.2>) todetermine outputs for the calculation tree 130 and, thus, the percentagevalues desired for the report.

The calculation tree 132 for the calculation expression <Calc4> includesa similar framework. The <Calc4> computation is broken down in FIG. 3 asa division operation <Calc4.1>/<Calc4.2>. As in the above-describedexample for <Calc3>, aggregation or summation of the data groups mayproceed via the data paths shown to determine the denominator (divisor)and numerator (dividend) of the division operation. One difference isthat the denominator (divisor), <Calc4.2>, involves the data groupaggregated at the country level rather than the region level. Thecomputation for Calc4.2 may be attained with the expression:Sum([Sales], Scope(“Country”,“Year”)), as described above. In thisexample, the computation for Calc4.1 may be attained with the expressionSum([Sales]), determined implicitly in the Country, Year, Channel scope.

FIG. 4 depicts another exemplary calculation methodology or scheme forthe multidimensional data scope computations. The above-describedcalculation trees are flattened into a series of nested calculations,where each level is a nested iterator over instances at that level. Forinstance, for each country, for each region, for each year, for eachchannel, compute the calculation expression <Calc3.1>. In this example,a nested series 150 is directed to computing the calculation expression<Calc3>, and a nested series 152 is directed to computing thecalculation expression <Calc4>.

In the nested series 150, the iterative computations for the <Calc3.2>calculations provide an output at the Year level to provide a totalacross all channels. The iterations continue for the <Calc3.1>calculations to provide respective subtotals at the channel scope.

The nested series 152 has a branched structure because a scope specifiedin the calculation is not aligned with the natural flattening of thecorresponding calculation tree. In this example, a set of aggregationsor summations labeled Year′ is created to accommodate the computationfor <Calc4.2>, which only involves the Country and Year scopes, therebyremoving the Region scope. The computation methodology or scheme maythus synthesize new branches of a calculation tree or data path toaccommodate those calculations which do not exist elsewhere in thereport or other data display.

Calculations on parallel branches of the nested series 152 (or othercalculation tree) may occur in parallel. Parallel processing may beuseful during the computation of the <Calc4> calculation. The parallelprocessing may help correlate each Calc4.1 value with the appropriateCalc4.2 value, thereby matching each the values for the Year aggregationwith those for Year′ aggregation. The values may be correlated in avariety of other ways.

Each data aggregation and summation for the Year′ portion of the nestedseries 152 may be discarded after the corresponding output value for the<Calc4> is determined. The data for the Year′ portion need not beactualized for, persisted in, or transmitted to, one or more memoriesassociated with, for instance, the rendering of the report. The use ofthe implicit creation of the computation branch for the Calc4.2calculation may thus be more efficient than the processing associatedwith reports in which the results of the Calc4.2 are explicitly made apart of the report.

FIGS. 5 and 6 provide another example in which a data scope isintroduced or originated within an aggregation operation. FIG. 5 depictsan exemplary report 160 having a tabular arrangement in which data isaggregated for a column scope for each year and a row scope for eachcountry. The report 160 lacks a column scope to aggregate data for eachmonth and, thus, there is no Month scope to support calculations ordeterminations at that level of detail. As described below, anappropriate data scope may be introduced or originated within anaggregation operation for which the data scope is used. In this example,aggregation operations are directed to determining the top month anddisplaying the total sales in that month. An embedded origination of adata scope at the month level of detail is provided as described below.

FIG. 6 is a schematic view of a report definition 162 for the report160. In this example, a calculation expression <Calc1> is intended topresent the total sales in a country for a given year. A calculationexpression <Calc2> is intended to present the total sales in a givenyear across all countries. The calculation expressions <Calc1> and<Calc2> may be implemented through implicit scoping as described above,in which case each expression may be set forth as Sum([Sales]). Acalculation expression <Calc7> is intended to present the total salesfor the month with the highest sales for a given year and country. Acalculation expression <Calc8> is intended to present the total salesfor the month with the highest sales for a given year across allcountries. In both cases, the data scope over which the total iscalculated is not present within the report definition 162, so there isno pre-existing data scope to be referenced in the calculationexpressions. For the calculation expression <Calc7>, the missing datascope corresponds with an intersection set that would aggregate data atthe Country, Year, and Month levels of detail. For the calculationexpression <Calc8>, the missing data scope corresponds with anintersection set that would aggregate data at the Year and Month levelsof detail.

An aggregation operation may introduce or originate a data scope toprovide the missing data scope. As in the embodiment described above,the data scope may be originated for the purpose of supporting theaggregation operation. The data scope may thus be dynamically generatedduring the implementation of the calculation expression.

The data aggregated in accordance with the data scope need not beretained, transmitted, or otherwise handled outside of the calculationexpression. Instantiation, persistence, and transmission, of such dataassociated with the data scope thus need not occur to support therendering of the report 160.

If the report definition 162 includes a Month data scope, then thecalculation expression <Calc8> may be set forth as Max(Sum([Sales],“Month”)) or, equivalently, Max(Sum([Sales], “Month”), “Year”). Ineither case, the inner Sum( ) aggregation operation computes the totalsales for each instance of the month within a given year. The outer Max() aggregation operation then uses the totals to determine the maximumtotal within each year.

The disclosed methods and systems allow the report developer to avoidhaving to expressly define and create the Month data scope in the reportdefinition 162 for incorporation into the report 160. Instead, eventhough the Month data scope does not exist elsewhere in the reportdefinition 162, the calculation expression <Calc8> may be set forth witha defining origination of the Month data scope within the calculationexpression. The definition of, and a reference to, the Month data scopemay thus be originated or synthesized in-line within the aggregationoperation. In this example, the definition of, and reference to, the newdata scope are expressed via a CreateScope( ) function. The calculationexpression <Calc8> may be set forth as follows:

-   -   Max(Sum([Sales], CreateScope(“Year”,[Month])))    -   or, alternatively,    -   Max(Sum([Sales], CreateScope(“Year”,[Month]), “Year”)).        The CreateScope function is configured as a declaration that        creates a Month scope as an inner scope, or child (or        descendant), of the existing Year scope. The inner Sum        aggregation operation then uses the Month scope to compute the        total sales for each instance of Month within a given Year.

The nature of the definition and reference to the data scope beingoriginated may vary the examples provided above. The reference need notrely on or include a function-based formulation. For instance, othertypes of declarations of the data scope may be used. One examplerepresentation for <Calc8> may be set forth as follows:

<Aggregation Type=“Max”>    <Aggregation Field=“Sales” Type=“Sum”/>   <Scope Type=“Inline”>       <ParentScope>Year</ParentScope>      <GroupBy Field=“Month”/>    </Scope> </Aggregation>

Data scopes originated in this manner may be referred to herein assynthetic data scopes. However, the origination of the data scope neednot involve the synthesis of multiple data scopes. The synthetic datascope may involve creating a data scope without a multidimensionalcombination, or intersection, of data scopes used elsewhere in thereport definition. The aggregation of data to determine a top salesmonth provides one example of the creation of a non-intersection-basedsynthetic data scope.

The calculation expression <Calc7> provides an example of anintersection-based synthetic data scope. The calculation expression<Calc7> involves an aggregation of data for each month and for eachcountry. The aggregation operation thus relies on a multidimensionalscope. The synthetic data scope is accordingly originated in conjunctionwith a reference to a multidimensional data scope. The multidimensionaldata scope reference may use the Scope( ) function described above. TheCreateScope( ) and Scope( ) functions may both be incorporated in-lineinto the aggregation operation as follows:

-   -   Max(Sum([Sales], Scope(“Country”,CreateScope(“Year”,[Month]))))        In this example, the CreateScope( ) function is nested within        the Scope( ) function, thereby allowing the Month data scope to        be created or synthesized as a part of the reference to the        multidimensional data scope to be used by the Max( ) aggregation        operation. As before, the CreateScope( ) function creates a        synthetic or original Month scope as a child of the existing        Year scope. The Scope( ) function then creates a        multidimensional scope with Country on one axis and the newly        created Month scope on the other axis.

In an alternative embodiment, the calculation expression <Calc7> may beset forth with an explicit data scope for the Max( ) aggregationoperation. The Scope( ) function or other declaration may be used toprovide the explicit data scope. The multidimensional aspect of the datascope may then be introduced within the declaration of the explicit datascope as follows:

Max(Sum([Sales],Scope(“Country”,CreateScope(“Year”,[Month]))),Scope(“Country”,“Year”)).The synthetic and multidimensional scopes may thus be simultaneouslyused in a variety of contexts.

FIG. 7 depicts an exemplary computation methodology or scheme forimplementing the calculation expressions <Calc7> and <Calc8> via theorigination of the Month data scope within the Max( ) aggregationoperation. Computations involving synthetic or original scopes mayproceed as described above in connection with implicit multidimensionalscopes, with a difference being the source of the grouping instructions.In the case of implicit multidimensional scopes, the groupinginstructions are obtained from the original data scopes introducedelsewhere in the report definition. In the case of synthetic scopes, thegrouping instructions may be explicitly defined in the computations forthe calculation expression in which the synthetic data scope isintroduced or otherwise originated.

The computation methodology may be configured as a calculation tree 170in which a Calc8.1 operation 172 corresponds with the inner Sum( )aggregation operation of the <Calc8> calculation expression, which iscalculated at or over the synthetic Month scope. The resulting data isthen re-aggregated via the Max( ) aggregation operation in a Calc8operation 174. A Calc7.1 operation 176 corresponds with the inner sum ofthe <Calc7> calculation expression, which is calculated at or over themultidimensional scope obtained from the intersection set of the Countryand Month scopes. The resulting data is then re-aggregated via the Max() aggregation operation in a Calc7 operation 178.

An alternative computation methodology for the calculation expressions<Calc7> and <Calc8> may involve flattening of the calculation tree 170.Such flattening may proceed in a manner similar to the flattening of thecalculation trees described above.

FIG. 8 depicts an exemplary system architecture 200 in which reportdefinitions are developed and in which reports are rendered from thereport definitions. The system architecture 200 may include a system202, such as a business intelligence system. The system 202 isconfigured to accommodate report definitions having one or moreoriginating references to data scopes as described above. The system 202or a subsystem or component thereof may be directed to or configured forreport definition development, interpreting report definitions,rendering of reports, or any combination thereof.

The reports developed or generated by the system 202 are configured topresent data from a dataset. The dataset may have any number of datasources. In this example, the system 202 obtains source data from asource database 204 and a number of source data files 206. The system202 may obtain the source data via one or more networks 208, such as theInternet, one or more extranets, a local area network (LAN), or variouscombinations thereof. The nature, number, format, layout, configuration,connectivity, and other characteristics of the source database 204 (ordatabases) and the source data files 206 may vary.

The system 202 may include a processing system 210, a memory 212, userinterface input devices 214, and a data display device 216 or otheroutput user interface. A variety of operators or other users may use theuser interface input devices 214 and other components of the system 202.For instance, report developers or designers may use the system 202 todevelop report definitions for reports and otherwise configure anend-user environment of the system 202. The system 202 may include anynumber of additional computers, devices, or other systems to generatevarious user interfaces or environments, including, for instance, one ormore development environments, one or more end-user environments, anadministrative user environment, etc.

The memory 212 may include any number of storage devices of varyingtypes or other data stores or memories. In this example, the memory 212includes one or more data stores 218 in which some or all of the datasetis stored after the data is extracted or otherwise obtained from thedata sources, one or more data files 220 in which the report definitionis stored, and one or more memories or data stores 222 in whichcomputer-readable instructions are stored for the processing system 210.For example, the computer-readable instructions may include dataextraction tool instructions, report development tool instructions,definition interpreter tool instructions, and rendering toolinstructions. Additional, fewer, or alternative instructions orinstruction sets may be stored in the memory 212. For example, thememory 212 may include one or more additional data stores in which datais stored during or after various operations, including, for instance,aggregation operations and other operations in which subsets or groupsof data are stored. Data for such subsets or groups may be persisted inthe additional data stores so that the data need not be re-extracted orre-aggregated from source data.

The processing system 210 may include any number of processors coupledto the memory 212. The processors may be distributed among any number ofcomputing devices, including, for instance, one or more server devicesand one or more client devices. The processing system 210 may beconfigured to execute the data extraction tool instructions to obtain orreceive or request data from the data sources, such as the sourcedatabase 204 and the source data files 206. The data extraction toolinstructions may configure the processing system 210 to store theextracted data in the data store 218. Data extraction may also includevarious processing of the extracted data in preparation for use inconnection with the report definition. The processing system 210 isconfigured to execute the development tool instructions to incorporate,into the report definition 220, a number of instructions for the layout,data, and other aspects of the report. The development tools may begraphical or textual, and may involve any type of user interface. Thedevelopment tool instructions may be implemented during a reportdevelopment phase or stage of system operation in which a reportdesigner or developer uses the system 202 to create the reportdefinition. The instructions in the report definition include a numberof calculation instructions or other expressions to populate the reportwith data aggregated from the dataset. The instructions or expressionsintroduce and/or define a number of data scopes for the dataset. Eachdata scope may specify a data field of the dataset to define respectivesubsets or groups of the dataset based on the data field. Variousfunctions or other operations may then be performed over such subsets orgroups to aggregate and process the data from the dataset.

As described above, each data scope specifies one or more data fields ofthe dataset to define a respective subset of the dataset. The processingsystem 210 (or one or more processors thereof) is further configured toincorporate, into the report definition, a calculation instruction orother expression for populating a unit or portion of the report. Forexample, the unit may correspond with a cell of a table or matrix, or anelement of a chart. The calculation expression sets forth, specifies,references, or otherwise includes a data aggregation function or otheroperation, such as a summing operation or an averaging operation. Asdescribed above, the data aggregation operation includes an originatingreference to a further data scope.

Once the report definition is developed, the processing system 210 (orone or more processors thereof) may be configured to interpret thereport definition in preparation for report generation or rendering. Inthis example, report interpretation may be implemented in accordancewith the interpreter tool instructions stored in the memory 212. Reportinterpretation may include parsing the report definition into objectsrepresentative of the operations, functions, data scopes, and otherelements specified via the report definition. Report interpretation mayfurther include the processing of such objects to utilize or generatecalculation trees and/or computation methodologies to support thecalculation expressions and other data processing tasks implicated bythe report definition.

Such processing of the report definition may include the configurationof the one or more data aggregation operations in the report definitionin accordance with originating data scope references embedded therein.An originating data scope reference may be configured as a functionembedded in a data aggregation operation and configured to create orotherwise specify a data scope for the operation. For example, theinterpreter tool instructions may be configured to allow the originatingdata scope reference to override an implicit data scope for a dataaggregation operation. As described above, such implicit data scopes maybe inferred from a location of the calculation expression (or dataaggregation operation) in the report definition. Alternatively oradditionally, the interpreter tool instructions may be configured torecognize that the originating data scope reference is identifying anintersection set of a number of the data scopes specified in the reportdefinition and/or a data scope not inferable from such intersections orcombinations of the other data scopes in the report definition.

The processing system 202 (or one or more processors thereof) may usethe results of the interpretation and other processing of the reportdefinition to render or generate the report. For example, the report maybe rendered on the data display device 216. The processing system 202may be configured with the rendering tool instructions to implement oneor more procedures involving the processing of the data subsets orgroups of the dataset as specified by the data scopes.

The report may be rendered via any display or output device incommunication with the processing system 210. The report may include orbe configured in a table, matrix, chart, any hybrid or other combinationthereof. Other report configurations or arrangements may be provided.The use or incorporation of originating data scope references asdescribed herein is not limited to any particular format or layout, andmay be used in connection with any type of reports, either existing orfuture developed. The characteristics of the report generated by thesystem 202 may vary accordingly. A report definition may include data orother information regarding the one or more sources of data from whichdata is obtained and/or processed to populate the report, includinginformation regarding the nature, structure, or other characteristics ofsuch data. A report definition may include layout or formattinginformation to specify how the data is presented in the report. A reportdefinition may include any number of parameters, properties, or otherattributes to specify other characteristics of the report.

FIG. 9 depicts an exemplary method for generating a report from a reportdefinition, the report definition specifying a plurality of data scopesfor a dataset. The method is computer-implemented. For example, theprocessing system 210 (or any one or more processors thereof) shown inFIG. 8 may be configured to implement one or more of the acts of themethod. The implementation of each act may be directed by respectivecomputer-readable instructions executed by the processing system 210 (orany one or more processors thereof) or another processing system.

The method may begin with any number of acts directed to the developmentof the report definition, as described above. The report definitionincludes at least one calculation instruction or other expression forpopulating a cell or other unit of the report with the results of a dataaggregation function or other operation. The data aggregation operationincludes an originating reference to a data scope as described above.The referenced data scope may not be otherwise referenced in the reportdefinition and, thus, need not involve the preparation of data fordisplay in the report.

The method may begin with an act 250 in which the report definition isinterpreted. The interpretation may include parsing and other processingof the instructions and other expressions in the report definition. Suchinterpretation may be implemented using any one or more of theprocessing systems or processors referenced herein. The parsing andother interpretation may analyze the calculation expressions in thereport definition to identify each instance of the various aggregationfunctions or operations and other objects specified therein, includingthose instances having an originating data scope reference. Explicit andimplicit data scopes for the aggregation operations may be identified.The originating references may be declared or incorporated in a mannerother than as an embedded function. The parsing and other interpretationof the report definition may vary based on the format, language, andother characteristics of the report definition.

The interpretation may include recognizing that one or more calculationexpressions include an instance of a data aggregation operation with anembedded function configured to originate a further data scope. Thefurther data scope may not be specified or defined in the reportdefinition outside of the calculation expression. As described above,the embedded function or other originating reference may override animplicit data scope for the data aggregation operation inferred from alocation of the calculation expression in the report definition. Theembedded function may be the above-described Scope( ) function, theabove-described CreateScope( ) function, or a nested or othercombination thereof. Recognition of the embedded function may thenprepare for implementation of the embedded function, including theexpectation of the function returning the further data scope as anargument for the data aggregation operation. With the further data scopeidentified, the interpretation may also include determining therespective subset(s) of the dataset to which the data aggregationoperation is to be applied.

As described above, the embedded function or other originating referencemay identify an intersection set of a number of data scopes specified inthe report definition. Each argument of the embedded function may berecognized to correspond with a respective data scope of the pluralityof data scopes specified in the report definition. Multidimensional datascopes may thus be created from the intersections of such scopes. Inother cases, the further data scope is not inferable from a combinationof the other data scopes in the report definition, in which case aCreateScope( ) function may be used. For example, the function may berecognized as having first and second arguments, the first argumentspecifying one of the plurality of data scopes as an outer data scopefor the further data scope, and the second argument specifying a datafield of the dataset to define respective subsets or groups of thedataset based on the data field, respectively. In such cases, thefurther data scope may nonetheless involve an intersection set betweenat least one scope not inferable from the plurality of data scopes.

In act 252, one or more memories or data stores are accessed to obtaindata to be processed in accordance with the calculation expressions andaggregation operations. The data is stored as a dataset in acentralized, distributed, or other manner. The memory(ies) or datastore(s) may be coupled to the processor or processing system. Data isobtained from the dataset for respective subsets of the datasetcorresponding with the data scopes referenced in the report definition,including those introduced by originating references.

Some or all of the respective subsets of the dataset for the data scopesmay be stored in an act 254. The subsets may be stored in an aggregatedformat in accordance with the data scopes. In one example, the manner inwhich the subsets are stored depends upon whether the report definitioncalls for such subsets to be instantiated and/or persisted for renderingin the report. For instance, subsets only used in connection withaggregation operations based on originating data scope references mayonly be stored in temporary files or other containers quickly accessibleby the processor or processing system. In contrast, data subsets orgroups to be rendered may be stored in more permanent files orcontainers and/or locations more appropriate for access during renderingof the report.

In act 256, the interpreted report definition may be processed todetermine output values or other outputs of the instructions,calculation instructions or expressions, and aggregation operationsthereof. In some calculations and operations, the output determinationmay be implemented as part of the act 254. For example, the datasubset(s) for a Sum( ) function may be stored as an aggregated totalbefore an output determination is made in connection with a calculationtree or other set of computations.

The output values may then be used to populate the cells or other unitsof the report in accordance with the formatting and other instructionsin the report definition. The population of the report may be integratedwith a number of processes directed to generating or rendering thereport in an act 258. The nature of the rendering act may vary accordingto the nature of the report.

The source data may be stored in, for instance, any combination of oneor more Extensible Markup Language (XML) files, flat files, databases,blobs in the cloud (e.g., elastic blobs), and various types of datatables.

The data aggregation operation may be configured as any summarizingfunction or operation. The nature of the summarizing function and/or thedata aggregation operation may vary. The data aggregation operation maybe configured to summarize or otherwise act on the data within the groupspecified via the scope.

With reference to FIG. 10, an exemplary computing environment 300 may beused to implement one or more aspects or elements of the above-describedmethods and/or systems. For example, the computing environment 300 ofFIG. 10 may be used by, or incorporated into, one or more elements ofthe system 202 (FIG. 8). The computing environment of FIG. 10 may beused or included as a client, network server, application server, ordatabase management system or other data store manager, of any of theaforementioned elements or system components. The computing environment300 of FIG. 10 may be used to implement one or more of the actsdescribed in connection with FIG. 9.

The computing environment 300 includes a general purpose computingdevice in the form of a computer 310. Components of computer 310 mayinclude, but are not limited to, a processing unit 320, a system memory330, and a system bus 321 that couples various system componentsincluding the system memory to the processing unit 320. The system bus321 may be any of several types of bus structures including a memory busor memory controller, a peripheral bus, and a local bus using any of avariety of bus architectures. By way of example, and not limitation,such architectures include Industry Standard Architecture (ISA) bus,Micro Channel Architecture (MCA) bus, Enhanced ISA (EISA) bus, VideoElectronics Standards Association (VESA) local bus, and PeripheralComponent Interconnect (PCI) bus also known as Mezzanine bus. The units,components, and other hardware of computer 310 may vary from the exampleshown.

Computer 310 typically includes a variety of computer readable storagemedia configured to store instructions and other data. Such computerreadable storage media may be any available media that may be accessedby computer 310 and includes both volatile and nonvolatile media,removable and non-removable media. By way of example, and notlimitation, such computer readable storage media may include computerstorage media as distinguished from communication media. Computerstorage media includes both volatile and nonvolatile, removable andnon-removable media implemented in any method or technology for storageof information such as computer readable instructions, data structures,program modules or other data. Computer storage media includes, but isnot limited to, RAM, ROM, EEPROM, flash memory or other memorytechnology, CD-ROM, digital versatile disks (DVD) or other optical diskstorage, magnetic cassettes, magnetic tape, magnetic disk storage orother magnetic storage devices, or any other medium which may be used tostore the desired information and which may accessed by computer 310.

The system memory 330 includes computer storage media in the form ofvolatile and/or nonvolatile memory such as read only memory (ROM) 331and random access memory (RAM) 332. A basic input/output system 333(BIOS), containing the basic routines that help to transfer informationbetween elements within computer 310, such as during start-up, istypically stored in ROM 331. RAM 332 typically contains data and/orprogram modules that are immediately accessible to and/or presentlybeing operated on by processing unit 320. By way of example, and notlimitation, FIG. 10 illustrates operating system 334, applicationprograms 335, other program modules 336, and program data 337. Forexample, one or more of the application programs 335 may be directed toimplementing the development tool instructions (FIG. 8). Alternativelyor additionally, the interpreter tool instructions (FIG. 8) may beimplemented via one or more of the other program modules 336. In this oranother example, any one or more the instruction sets in the memories ordata stores 222 (FIG. 8) may be stored as program data 337.

Any one or more of the operating system 334, the application programs335, the other program modules 336, and the program data 337 may bestored on, and implemented via, a system on a chip (SOC). Any of theabove-described modules may be implemented via one or more SOC devices.The extent to which the above-described modules are integrated in a SOCor other device may vary.

The computer 310 may also include other removable/non-removable,volatile/nonvolatile computer storage media. By way of example only,FIG. 10 illustrates a hard disk drive 341 that reads from or writes tonon-removable, nonvolatile magnetic media, a magnetic disk drive 351that reads from or writes to a removable, nonvolatile magnetic disk 352,and an optical disk drive 355 that reads from or writes to a removable,nonvolatile optical disk 356 such as a CD ROM or other optical media.Other removable/non-removable, volatile/nonvolatile computer storagemedia that may be used in the exemplary operating environment include,but are not limited to, magnetic tape cassettes, flash memory cards,digital versatile disks, digital video tape, solid state RAM, solidstate ROM, and the like. The hard disk drive 341 is typically connectedto the system bus 321 through a non-removable memory interface such asinterface 340, and magnetic disk drive 351 and optical disk drive 355are typically connected to the system bus 321 by a removable memoryinterface, such as interface 350.

The drives and their associated computer storage media discussed aboveand illustrated in FIG. 10, provide storage of computer readableinstructions, data structures, program modules and other data for thecomputer 310. In FIG. 10, for example, hard disk drive 341 isillustrated as storing operating system 344, application programs 345,other program modules 346, and program data 347. These components mayeither be the same as or different from operating system 334,application programs 335, other program modules 336, and program data337. Operating system 344, application programs 345, other programmodules 346, and program data 347 are given different numbers here toillustrate that, at a minimum, they are different copies. A user mayenter commands and information into the computer 310 through inputdevices such as a keyboard 362 and pointing device 361, commonlyreferred to as a mouse, trackball or touch pad. Other input devices (notshown) may include a microphone (e.g., for voice control), touchscreen(e.g., for touch-based gestures and other movements), ranger sensor orother camera (e.g., for gestures and other movements), joystick, gamepad, satellite dish, and scanner. These and other input devices areoften connected to the processing unit 320 through a user inputinterface 360 that is coupled to the system bus, but may be connected byother interface and bus structures, such as a parallel port, game portor a universal serial bus (USB). A monitor 391 or other type of displaydevice is also connected to the system bus 321 via an interface, such asa video interface 390. In addition to the monitor, computers may alsoinclude other peripheral output devices such as speakers 397 and printer396, which may be connected through an output peripheral interface 395.

The computer 310 may operate in a networked environment using logicalconnections to one or more remote computers, such as a remote computer380. The remote computer 380 may be a personal computer, a server, arouter, a network PC, a peer device or other common network node, andtypically includes many or all of the elements described above relativeto the computer 310, although only a memory storage device 381 has beenillustrated in FIG. 10. The logical connections depicted in FIG. 10include a local area network (LAN) 371 and a wide area network (WAN)373, but may also include other networks. Such networking environmentsare commonplace in offices, enterprise-wide computer networks, intranetsand the Internet.

When used in a LAN networking environment, the computer 310 is connectedto the LAN 371 through a network interface or adapter 370. When used ina WAN networking environment, the computer 310 typically includes amodem 372 or other means for establishing communications over the WAN373, such as the Internet. The modem 372, which may be internal orexternal, may be connected to the system bus 321 via the user inputinterface 360, or other appropriate mechanism. In a networkedenvironment, program modules depicted relative to the computer 310, orportions thereof, may be stored in the remote memory storage device. Byway of example, and not limitation, FIG. 10 illustrates remoteapplication programs 385 as residing on memory device 381. It will beappreciated that the network connections shown are exemplary and othermeans of establishing a communications link between the computers may beused.

The computing environment 300 of FIG. 10 is only one example of asuitable computing environment and is not intended to suggest anylimitation as to the scope of use or functionality of the technologyherein. Neither should the computing environment 300 be interpreted ashaving any dependency or requirement relating to any one or combinationof components illustrated in the exemplary operating environment 300.

The technology described herein is operational with numerous othergeneral purpose or special purpose computing system environments orconfigurations. Examples of well-known computing systems, environments,and/or configurations that may be suitable for use with the technologyherein include, but are not limited to, personal computers, servercomputers (including server-client architectures), hand-held or laptopdevices, mobile phones or devices, multiprocessor systems,microprocessor-based systems, set top boxes, programmable consumerelectronics, network PCs, minicomputers, mainframe computers,distributed computing environments that include any of the above systemsor devices, and the like.

The technology herein may be described in the general context ofcomputer-executable instructions, such as program modules, beingexecuted by a computer. Generally, program modules include routines,programs, objects, components, data structures, and so forth thatperform particular tasks or implement particular abstract data types.The technology herein may also be practiced in distributed computingenvironments where tasks are performed by remote processing devices thatare linked through a communications network. In a distributed computingenvironment, program modules may be located in both local and remotecomputer storage media including memory storage devices.

This disclosed methods, systems, and computer program products supportthe development of reports in which, for example, (1) a calculationincludes references to a number of implicit ancestor (or outer) groupscopes to originate a group scope along one or more multidimensionaldata axes, (2) synthetic group scopes are defined within calculationswhich use the synthetic group scope, and (3) multidimensional syntheticgroup scopes are defined, both with and without non-synthetic scopesalong one or more axes.

The disclosed methods and systems may utilize or support data displaylanguage constructs by which a data display author incorporate ororiginate data scopes in an efficient manner as described above. Thedisclosed methods and systems may be configured to interpret theconstructs to translate the constructs and any related instructions intocomputer-executable instructions to implement various underlyingcalculations.

While the present invention has been described with reference tospecific examples, which are intended to be illustrative only and not tobe limiting of the invention, it will be apparent to those of ordinaryskill in the art that changes, additions and/or deletions may be made tothe disclosed embodiments without departing from the spirit and scope ofthe invention.

The foregoing description is given for clearness of understanding only,and no unnecessary limitations should be understood therefrom, asmodifications within the scope of the invention may be apparent to thosehaving ordinary skill in the art.

1. A computer-implemented method for generating a report from a reportdefinition, the report definition specifying a plurality of data scopesfor a dataset, the method comprising: interpreting, with a processor, areport definition for the report, the report definition comprising acalculation expression for populating a unit of the report, thecalculation expression comprising a data aggregation operation, the dataaggregation operation comprising an originating reference to a furtherdata scope; accessing a memory coupled to the processor to obtain datafrom the dataset for respective subsets of the dataset correspondingwith the further data scope; determining, with the processor, an outputvalue for the calculation expression in accordance with the obtaineddata and the data aggregation operation; and rendering the report basedon the output value.
 2. The computer-implemented method of claim 1,wherein the originating reference overrides an implicit data scope forthe data aggregation operation inferred from a location of thecalculation expression in the report definition.
 3. Thecomputer-implemented method of claim 1, wherein the originatingreference identifies an intersection set of a number of the plurality ofdata scopes specified in the report definition.
 4. Thecomputer-implemented method of claim 1, wherein the further data scopeis not inferable from a combination of a number of the plurality of datascopes in the report definition.
 5. The computer-implemented method ofclaim 4, wherein the further data scope corresponds with an intersectionset involving at least one scope not inferable from the plurality ofdata scopes.
 6. The computer-implemented method of claim 1, wherein theoriginating reference is configured as a function embedded in the dataaggregation operation and configured to specify the further data scope.7. The computer-implemented method of claim 6, wherein each argument ofthe function corresponds with a respective data scope of the pluralityof data scopes specified in the report definition.
 8. Thecomputer-implemented method of claim 7, wherein the function isconfigured to define the further data scope based on an intersection setof the data scopes specified in the arguments.
 9. Thecomputer-implemented method of claim 6, wherein the function isconfigured with first and second arguments, the first argumentspecifying one of the plurality of data scopes as an outer data scopefor the further data scope, and the second argument specifying a datafield of the dataset to define respective subsets of the dataset basedon the data field, respectively.
 10. The computer-implemented method ofclaim 1, wherein the further data scope is not specified in the reportdefinition outside of the calculation expression.
 11. Thecomputer-implemented method of claim 1, wherein each data scope of theplurality of data scopes specifies a data field of the dataset to definerespective subsets of the dataset based on the data field.
 12. A systemfor developing a report definition for a report for presentation of datafrom a dataset, the system comprising: a memory in which developmenttool instructions and interpreter tool instructions are stored; aprocessor coupled to the memory configured to execute the developmenttool instructions to: incorporate, into the report definition,references to a plurality of data scopes for the dataset, each datascope specifying one or more data fields of the dataset to define arespective subset of the dataset; and incorporate, into the reportdefinition, a calculation expression for populating a unit of thereport, the calculation expression comprising a data aggregationoperation, the data aggregation operation comprising an originatingreference to a further data scope; wherein the processor is furtherconfigured to execute the interpreter tool instructions to configure thedata aggregation operation in accordance with the further data scope.13. The system of claim 12, wherein the originating reference overridesan implicit data scope for the data aggregation operation inferred froma location of the calculation expression in the report definition. 14.The system of claim 12, wherein the originating reference identifies anintersection set of a number of the plurality of data scopes specifiedin the report definition.
 15. The system of claim 12, wherein thefurther data scope is not inferable from a combination of a number ofthe plurality of data scopes in the report definition.
 16. The system ofclaim 12, wherein the originating reference is configured as a functionembedded in the data aggregation operation and configured to specify thefurther data scope.
 17. A computer program product comprising one ormore computer-readable storage media in which computer-readableinstructions are stored that, when executed by a processing system,direct the processing system to: parse a report definition for a reportto identify a calculation expression for populating a unit of thereport, the calculation expression comprising an instance of a dataaggregation operation, the report definition specifying a plurality ofdata scopes for a dataset, each data scope specifying one or more datafields of the dataset to define respective subsets of the dataset basedon the data field; determine an output of the calculation expression inaccordance with the data aggregation operation; and render the reportwith the determined output; wherein the instance of the data aggregationoperation comprises an embedded function configured to originate afurther data scope, and wherein the calculation expression is configuredsuch that implementation of the embedded function returns the furtherdata scope as an argument for the data aggregation operation todetermine a further respective subset of the dataset to which the dataaggregation operation is applied.
 18. The computer program product ofclaim 17, wherein the embedded function overrides an implicit data scopefor the data aggregation operation inferred from a location of thecalculation expression in the report definition.
 19. The computerprogram product of claim 17, wherein the embedded function identifies anintersection set of a number of the plurality of data scopes specifiedin the report definition.
 20. The computer program product of claim 17,wherein the further data scope is not inferable from a combination of anumber of the plurality of data scopes in the report definition.